From an Empty Folder to a Running Web Server
Welcome to Module 2! In the last section, we covered the theory—the "what" and the "why." Now, it's time to transition from concepts to code. This module is all about action. We will set up a professional, clean, and scalable project environment from scratch. This is one of the most critical steps in a developer's workflow.
A solid foundation makes the rest of the building process smoother, more organized, and easier to manage. We'll create a dedicated workspace for our project, organize our files logically, and finish with the traditional "Hello, World!" moment: seeing our very own web application running live in the browser. Let's get our tools ready and start building.
Imagine you're a chef. You have two very different recipes to prepare. One is a spicy curry that requires a specific set of rare spices. The other is a delicate cake that requires fine baking powder. You wouldn't just throw all your ingredients together on one counter, right? You'd keep them separate to avoid mixing flavors. A **virtual environment** is a dedicated, clean kitchen for each of your Python projects.
Every project has its own "dependencies"—external libraries like Flask that it depends on. By creating a virtual environment, we ensure that the dependencies for our pizza project don't conflict with dependencies for another project. It's a fundamental best practice for professional Python development.
Open your computer's terminal (Command Prompt or PowerShell on Windows, Terminal on Mac/Linux). Navigate to where you want to store your project, and let's begin.
1. Create the environment:
python3: We're using the Python 3 interpreter.-m venv: We're telling Python to run its built-in venv module.venv: This is the name we're giving to the folder that will contain our virtual environment. It's a common convention to name it "venv".2. Activate the environment:
This "turns on" the isolated environment. The command is different for Windows vs. Mac/Linux.
On Mac/Linux:
On Windows (Command Prompt):
(venv) at the beginning. This is your visual cue that the private workshop is active!
3. Install Flask:
Now that our environment is active, we can install our main library using pip, Python's package manager.
pip to fetch these packages from the Python Package Index (PyPI) and install them *inside* our active `venv` folder, leaving our global Python installation untouched.
You could put all your code in a single file, but as the application grows, it would become an unmanageable mess. A well-organized file structure is like the blueprint for a house: it ensures every room has its place, making it easy to find things and add new rooms later.
We will use a common and scalable pattern where our main application logic lives inside a dedicated package (the `app` folder). Create the following folders and files inside your main project directory (e.g., `pizza_project`).
run.py is the entry point. Its only job is to start the server. It's clean and simple.app/ folder contains the application itself. This makes the core logic portable and well-organized. This structure avoids "circular imports" and is a hallmark of professional Flask development.__init__.py is a special file. It runs automatically when the `app` package is imported and is the perfect place to create our Flask application instance and configure it.It's time to write our first lines of Flask code. This simple application will start a web server and display a message in your browser, confirming that our setup is correct.
We'll add code to two files: `app/__init__.py` to create the app, and `run.py` to run it.
1. In app/__init__.py, add the following:
from flask import Flask: We import the main Flask class.app = Flask(__name__): This is the magic line. We create an object named `app` from the `Flask` class. Flask uses the `__name__` variable to determine the root path of the application so it can find resource files (like templates).from app import routes: We import our routes file. This might seem strange (it's at the bottom), but it's to avoid circular import errors, as our `routes.py` file will in turn need to import the `app` variable we just created.2. In `app/routes.py`, add the following:
from app import app: Here, we import the `app` instance we created in our `__init__.py`.@app.route('/'): This is a Python "decorator." It's a special syntax that links a URL to a Python function. Here, we're linking the root URL of our site (`/`) to the `index` function below it.def index():: This is our "view function."return '...': Whatever a view function returns is what the user's browser will receive. For now, it's just a simple string of HTML.3. In the top-level `run.py`, add the following:
from app import app: We import our application instance from the `app` package.if __name__ == '__main__':: This is a standard Python construct. It ensures the code inside this block only runs when you execute the file directly (python run.py).app.run(debug=True): This command starts Flask's built-in development web server. Setting debug=True is a lifesaver: it provides detailed error pages and automatically reloads the server every time you save a file.Make sure your virtual environment is still active (`(venv)` should be in your prompt). In your terminal, at the root of your `pizza_project` folder, run the command:
You should see output that looks something like this:
Open your web browser and navigate to http://127.0.0.1:5000. You should see "Hello, Pizza Lovers!" displayed on the page. Congratulations, you've just built and launched your first web application!
Excellent work! This was a dense but incredibly important module. You have successfully created a professional project structure, learned the critical role of virtual environments, and launched a live web server on your machine. This robust skeleton will now support the rest of our application's features.
In the next module, we will bring our application to life by designing our database and connecting it to our Flask app. This is where we start working with real data.